In [1]:
#import libraries
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
import warnings
warnings.simplefilter("ignore")
In [2]:
#import datafile
vehicle=pd.read_csv("vehicle-1.csv")
vehicle.head()
Out[2]:
In [3]:
#Data type of variables in data
vehicle.info()
In [4]:
vehicle.shape
Out[4]:
In [5]:
#there are many columns which contain missing value
vehicle.isna().sum()
Out[5]:
In [6]:
vehicle.describe()
Out[6]:
Data Exploration¶
UNIVARIATE ANALYSIS¶
In [7]:
#compactness, circularity, distance_circularity, radius_ratio, elongatedness, max.length_rectangularity,
#scaled_radius_of_gyration,skewness_about.2,hollows_ratio are approximately symmetric
#scatter_ratio, pr.axis_rectangularity, scaled_variance, scaled_variance.1,
#skewness_about, skewness_about.1 are moderately right skewed
#pr.axis_aspect_ratio, max.length_aspect_ratio, scaled_radius_of_gyration.1 are highly right skewed
vehicle.skew()
Out[7]:
In [8]:
#Compactness is aproxmiately symetric, its a mutlimodal distribution
sns.kdeplot(vehicle["compactness"])
Out[8]:
In [9]:
#Circularity is aproxmiately symetric, its a mutlimodal distribution
sns.kdeplot(vehicle["circularity"])
Out[9]:
In [10]:
#Distance_circularity contains mutlimodal distribution
sns.kdeplot(vehicle["distance_circularity"])
Out[10]:
In [11]:
#radius ratio contains mutlimodal distribution. Contains many value distribution at peak
sns.kdeplot(vehicle["radius_ratio"])
Out[11]:
In [12]:
#pr.axis_aspect_ratio is left skewed and has mutlimodal distribution
sns.kdeplot(vehicle["pr.axis_aspect_ratio"])
Out[12]:
In [13]:
#max.length_aspect_ratio is left skewed and has bimodal distribution
sns.kdeplot(vehicle["max.length_aspect_ratio"])
Out[13]:
In [14]:
#scatter_ratio has aprox symetric distribution with mutlimodal distribution
sns.kdeplot(vehicle["scatter_ratio"])
Out[14]:
In [15]:
#elongatedness has aprox symetric distribution with mutlimodal distribution
sns.kdeplot(vehicle["elongatedness"])
Out[15]:
In [16]:
#pr.axis_rectangularity is slightly left skewed with mutlimodal distribution
sns.kdeplot(vehicle["pr.axis_rectangularity"])
Out[16]:
In [17]:
#max.length_rectangularity contains mutlimodal distribution
sns.kdeplot(vehicle["max.length_rectangularity"])
Out[17]:
In [18]:
#scaled_variance is slightly left skewed with miltimodal distribution
sns.kdeplot(vehicle["scaled_variance"])
Out[18]:
In [19]:
#scaled_variance.1 is left skewed with miltimodal distribution
sns.kdeplot(vehicle["scaled_variance.1"])
Out[19]:
In [20]:
#scaled_radius_of_gyration contains miltimodal distribution
sns.kdeplot(vehicle["scaled_radius_of_gyration"])
Out[20]:
In [21]:
#scaled_radius_of_gyration.1 is left skewed and conatins multimodal distribution
sns.kdeplot(vehicle["scaled_radius_of_gyration.1"])
Out[21]:
In [22]:
#skewness_about is left skewed with multimodal disrtibution
sns.kdeplot(vehicle["skewness_about"])
Out[22]:
In [23]:
#skewness_about.1 is left skewed with multimodal disrtibution
sns.kdeplot(vehicle["skewness_about.1"])
Out[23]:
In [24]:
#skewness_about.2 conatins multimodal disrtibution
sns.kdeplot(vehicle["skewness_about.2"])
Out[24]:
In [25]:
#hollows_ratio contains multimodal distibution
sns.kdeplot(vehicle["hollows_ratio"])
Out[25]:
In [26]:
#Features is most cases have multimodal distribution
In [27]:
sns.boxplot(vehicle["compactness"])
Out[27]:
In [28]:
sns.boxplot(vehicle["circularity"])
Out[28]:
In [29]:
sns.boxplot(vehicle["distance_circularity"])
Out[29]:
In [30]:
#radius_ration has samll number of outliers
sns.boxplot(vehicle["radius_ratio"])
Out[30]:
In [31]:
#pr.axis_aspect_ratio has outliers
sns.boxplot(vehicle["pr.axis_aspect_ratio"])
Out[31]:
In [32]:
#max.length_aspect_ratio contains outliers
sns.boxplot(vehicle["max.length_aspect_ratio"])
Out[32]:
In [33]:
sns.boxplot(vehicle["scatter_ratio"])
Out[33]:
In [34]:
sns.boxplot(vehicle["elongatedness"])
Out[34]:
In [35]:
sns.boxplot(vehicle["pr.axis_rectangularity"])
Out[35]:
In [36]:
sns.boxplot(vehicle["max.length_rectangularity"])
Out[36]:
In [37]:
sns.boxplot(vehicle["scaled_variance"])
Out[37]:
In [38]:
sns.boxplot(vehicle["scaled_variance.1"])
Out[38]:
In [39]:
sns.boxplot(vehicle["scaled_radius_of_gyration"])
Out[39]:
In [40]:
#scaled_radius_of_gyration.1 contains outliers
sns.boxplot(vehicle["scaled_radius_of_gyration.1"])
Out[40]:
In [41]:
sns.boxplot(vehicle["skewness_about"])
Out[41]:
In [42]:
sns.boxplot(vehicle["skewness_about.1"])
Out[42]:
In [43]:
sns.boxplot(vehicle["skewness_about.2"])
Out[43]:
In [44]:
sns.boxplot(vehicle["hollows_ratio"])
Out[44]:
In [45]:
#Most of the feature distribution seems fine, while few conatin outliers
In [46]:
#Data has most cases of car, followed by bus and van
vehicle["class"].value_counts()
Out[46]:
BIVARIATE ANALYSIS¶
In [47]:
#We can see features distributed on class have different mean values
vehicle.groupby(["class"]).agg('mean')
Out[47]:
In [48]:
#We can see features distributed on class have different median values
vehicle.groupby(["class"]).agg('median')
Out[48]:
In [49]:
## mean and median have seprable values for 3 given class of vehicle
## will use median to compute blank variable as data is skewed
In [50]:
sns.boxplot(x='class',y='compactness',data=vehicle)
Out[50]:
In [51]:
sns.boxplot(x='class',y='circularity',data=vehicle)
Out[51]:
In [52]:
sns.boxplot(x='class',y='distance_circularity',data=vehicle)
Out[52]:
In [53]:
sns.boxplot(x='class',y='radius_ratio',data=vehicle)
Out[53]:
In [54]:
sns.boxplot(x='class',y='pr.axis_aspect_ratio',data=vehicle)
Out[54]:
In [55]:
sns.boxplot(x='class',y='max.length_aspect_ratio',data=vehicle)
Out[55]:
In [56]:
sns.boxplot(x='class',y='scatter_ratio',data=vehicle)
Out[56]:
In [57]:
sns.boxplot(x='class',y='elongatedness',data=vehicle)
Out[57]:
In [58]:
sns.boxplot(x='class',y='pr.axis_rectangularity',data=vehicle)
Out[58]:
In [59]:
sns.boxplot(x='class',y='max.length_rectangularity',data=vehicle)
Out[59]:
In [60]:
sns.boxplot(x='class',y='scaled_variance',data=vehicle)
Out[60]:
In [61]:
sns.boxplot(x='class',y='scaled_variance.1',data=vehicle)
Out[61]:
In [62]:
sns.boxplot(x='class',y='scaled_radius_of_gyration',data=vehicle)
Out[62]:
In [63]:
sns.boxplot(x='class',y='scaled_radius_of_gyration.1',data=vehicle)
Out[63]:
In [64]:
sns.boxplot(x='class',y='skewness_about',data=vehicle)
Out[64]:
In [65]:
sns.boxplot(x='class',y='skewness_about.1',data=vehicle)
Out[65]:
In [66]:
sns.boxplot(x='class',y='skewness_about.2',data=vehicle)
Out[66]:
In [67]:
sns.boxplot(x='class',y='hollows_ratio',data=vehicle)
Out[67]:
In [68]:
#as stated above featues have different values distribution, thus the classes are easily seprable. However we cannot
#distiguish among 2 cars.
In [69]:
## Filling blanks for respective col with median as per class
In [70]:
vehicle_col=['compactness', 'circularity', 'distance_circularity', 'radius_ratio', 'pr.axis_aspect_ratio',
'max.length_aspect_ratio', 'scatter_ratio','elongatedness', 'pr.axis_rectangularity',
'max.length_rectangularity', 'scaled_variance', 'scaled_variance.1', 'scaled_radius_of_gyration',
'scaled_radius_of_gyration.1', 'skewness_about', 'skewness_about.1', 'skewness_about.2', 'hollows_ratio']
for item in vehicle_col:
vehicle[item].fillna(vehicle.groupby('class')[item].transform('median'),inplace=True)
In [71]:
vehicle.info()
In [72]:
#Now there are no blanks in data
vehicle.isna().sum()
Out[72]:
In [73]:
#Many features have high correlation value among each other
corr=vehicle.corr()
plt.subplots(figsize =(15, 10))
sns.heatmap(corr,cmap="YlGnBu",annot=True)
Out[73]:
In [74]:
#many features are correlated to each other is visible form the pairplot graph
sns.pairplot(vehicle)
Out[74]:
In [75]:
sns.pairplot(vehicle,hue='class')
Out[75]:
In [76]:
#There are few variables which exibhit weak realtionship
#There is no variable which clearly distincts between 3 groups, data seems to be overlapping. However there peak value,
#or part of some distribution differs. Thus hope these features give good value when implemented in algorithm
#Many variables are highly correlated, thus can use PCA.
In [77]:
vehicle.groupby('class').quantile([.25, .5, .75, .90, .95, .99,1])
Out[77]:
In [78]:
## There doesnt seem to be anything some unusual value in data, for now keeping data as is rather removing any outliers
In [79]:
#Seprating in X and Y
X_vehicle=vehicle.drop(['class'],1)
y_vehicle=vehicle['class']
print(X_vehicle.shape)
print(y_vehicle.shape)
In [80]:
#### Preprocessing of data for standardization
In [81]:
from sklearn.preprocessing import scale
X_std = scale(X_vehicle)
In [82]:
X_std=pd.DataFrame(X_std,columns=X_vehicle.columns)
X_std.head()
Out[82]:
Test Train Split of the data¶
In [83]:
from sklearn.model_selection import train_test_split
In [84]:
X_train_std, X_test, y_train,y_test=train_test_split(X_std,y_vehicle,test_size=0.2,random_state=100)
Using PCA - Principal Component Analysis¶
In [85]:
from sklearn.decomposition import PCA
pca=PCA(svd_solver='randomized',random_state=10)
In [86]:
#Applying pca on train dataset
pca.fit(X_train_std)
Out[86]:
In [87]:
pca.components_
Out[87]:
In [88]:
pca.explained_variance_
Out[88]:
In [89]:
pca.explained_variance_ratio_
Out[89]:
In [90]:
colnames = list(X_vehicle.columns)
pcs_vehicle_df = pd.DataFrame({'PC1':pca.components_[0],'PC2':pca.components_[1],'PC3':pca.components_[2],
'PC4':pca.components_[3], 'PC5':pca.components_[4], 'PC6':pca.components_[5],
'PC7':pca.components_[6], 'PC8':pca.components_[7], 'PC9':pca.components_[8],
'PC10':pca.components_[9], 'PC11':pca.components_[10], 'PC12':pca.components_[11],
'PC13':pca.components_[12], 'PC14':pca.components_[13], 'PC15':pca.components_[14],
'PC16':pca.components_[15], 'PC17':pca.components_[16],'PC18':pca.components_[17],'Feature':colnames})
pcs_vehicle_df.head()
Out[90]:
In [91]:
#Making the screeplot - plotting the cumulative variance against the number of components
%matplotlib inline
fig = plt.figure(figsize = (10,6))
plt.plot(range(1,19,1),np.cumsum(pca.explained_variance_ratio_))
plt.xlabel('number of components')
plt.ylabel('cumulative explained variance')
plt.show()
In [92]:
#Graph of individual explained variance and cumulative explained variance against Principal Components
fig = plt.figure(figsize = (10,6))
plt.bar(range(1,19), pca.explained_variance_ratio_, alpha=0.5, align='center', label='individual explained variance')
plt.step(range(1,19),np.cumsum(pca.explained_variance_ratio_), where= 'mid', label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.legend(loc = 'best')
Out[92]:
In [93]:
np.cumsum(pca.explained_variance_ratio_)
Out[93]:
In [94]:
## 7 components explained almost 96% of varitation in data.
In [95]:
pca_final=PCA(n_components=7)
X_pca=pca_final.fit_transform(X_train_std)
X_train_pca=pd.DataFrame(X_pca,columns=['PC1','PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7'])
type(X_train_pca)
X_train_pca.shape
Out[95]:
In [96]:
#Applying on test data
X_test_pca=pca_final.transform(X_test)
X_test_pca=pd.DataFrame(X_test_pca,columns=['PC1','PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7'])
type(X_test_pca)
X_test_pca.shape
Out[96]:
In [97]:
## there is very low correlation among the PCA variables
plt.figure(figsize=(10,10))
print(sns.heatmap(X_train_pca.corr(),annot=True))
print(sns.heatmap(X_test_pca.corr(),annot=True))
In [98]:
from sklearn.svm import SVC
from sklearn import metrics
from sklearn.model_selection import validation_curve
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV
In [99]:
#Model Building using SVC - Support Vector Classifier
svc_1=SVC(C=1,kernel='linear',random_state=100)
svc_1.fit(X_train_std,y_train)
# predict
y_pred_test = svc_1.predict(X_test)
In [100]:
# confusion matrix
confusion = metrics.confusion_matrix(y_test, y_pred_test)
confusion
Out[100]:
In [101]:
# measure accuracy
metrics.accuracy_score(y_test, y_pred_test)
Out[101]:
In [102]:
# class-wise result without pca
#precision - a class labelled as car turns is correct 96% of the time, similarly for other classes as well.
#recall - car is actually recognized as car 94% of time by algo, similarly for other classes as well.
#So model does a good job with accuracy of 94%
class_wise = metrics.classification_report(y_true=y_test, y_pred=y_pred_test)
print(class_wise)
In [103]:
#Using PCA with SVC
In [104]:
#Model Building
svc_1.fit(X_train_pca,y_train)
# predict
y_pred_test_pca = svc_1.predict(X_test_pca)
In [105]:
#confusiuon matrix
confusion_pca = metrics.confusion_matrix(y_test,y_pred_test_pca)
confusion_pca
Out[105]:
In [106]:
# measure accuracy
metrics.accuracy_score(y_test, y_pred_test_pca)
Out[106]:
In [107]:
# class-wise result with pca - clearly results performance has decreased a lot. Maybe lets try increasing the PCA components
#from 7 to 9
class_wise_pca = metrics.classification_report(y_test, y_pred_test_pca)
print(class_wise_pca)
In [108]:
pca_final1=PCA(n_components=9)
X_pca1=pca_final1.fit_transform(X_train_std)
X_train_pca1=pd.DataFrame(X_pca1,columns=['PC1','PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9'])
#type(X_train_pca1)
#X_train_pca1.shape
#Applying on test data
X_test_pca1=pca_final1.transform(X_test)
X_test_pca1=pd.DataFrame(X_test_pca1,columns=['PC1','PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9'])
#type(X_test_pca1)
#X_test_pca1.shape
#Model Building
svc_1.fit(X_train_pca1,y_train)
# predict
y_pred_test_pca1 = svc_1.predict(X_test_pca1)
In [109]:
#confusiuon matrix
confusion_pca1 = metrics.confusion_matrix(y_test,y_pred_test_pca1)
confusion_pca1
Out[109]:
In [110]:
# measure accuracy
metrics.accuracy_score(y_test, y_pred_test_pca1)
Out[110]:
In [111]:
# class-wise
class_wise_pca1 = metrics.classification_report(y_test, y_pred_test_pca1)
print(class_wise_pca1)
In [112]:
##Clearly SVC without PCA gives better results with improvement in accuracy as well
In [113]:
#Using GridSearchCV first on SVC model
In [114]:
#Regularization using GridSearchCV
params = {"kernel": ['linear', 'rbf'],"gamma":[0.1, 1, 10, 100],'C': [0.5,1,10,100]}
In [115]:
from sklearn.model_selection import GridSearchCV
model_cv = GridSearchCV(estimator = svc_1, param_grid = params,
scoring= 'accuracy',
cv=3,
verbose = 1,
return_train_score=True)
In [116]:
model_cv.fit(X_train_std, y_train)
# results of grid search CV
cv_results = pd.DataFrame(model_cv.cv_results_)
#cv_results
#parameters best value
best_score = model_cv.best_score_
best = model_cv.best_params_
best
Out[116]:
In [117]:
#using best parameter values
model_best = SVC(kernel='rbf' ,gamma =0.1 ,C =10)
model_best.fit(X_train_std, y_train)
# predict
y_pred_best = model_best.predict(X_test)
In [118]:
#confusiuon matrix
confusion_gcv = metrics.confusion_matrix(y_test,y_pred_best)
confusion_gcv
Out[118]:
In [119]:
# measure accuracy
print("Accuracy: ",metrics.accuracy_score(y_test, y_pred_best))
# class-wise result with GridSearchCV selected model
class_wise_gcv = metrics.classification_report(y_test, y_pred_best)
print(class_wise_gcv)
In [120]:
#The model has improved with GridSearch. Now lets try GridSearch with 9 components of PCA
In [121]:
#Regularization using GridSearchCV
params = {"kernel": ['linear', 'rbf'],"gamma":[0.1, 1, 10, 100],'C': [0.5,1,10,100]}
model_cv1 = GridSearchCV(estimator = svc_1, param_grid = params,
scoring= 'accuracy',
cv=3,
verbose = 1,
return_train_score=True)
model_cv1.fit(X_train_pca1,y_train)
# results of grid search CV
cv_results1 = pd.DataFrame(model_cv1.cv_results_)
#cv_results1
#parameters best value
best_score1 = model_cv1.best_score_
best1 = model_cv1.best_params_
best1
Out[121]:
In [122]:
#using best parameter values
model_best1 = SVC(kernel='rbf' ,gamma =0.1 ,C =10)
model_best1.fit(X_train_pca1,y_train)
# predict
y_pred_best1 = model_best1.predict(X_test_pca1)
In [123]:
#confusiuon matrix
confusion_gcv1 = metrics.confusion_matrix(y_test,y_pred_best1)
confusion_gcv1
Out[123]:
In [124]:
# measure accuracy
metrics.accuracy_score(y_test, y_pred_best1)
Out[124]:
In [125]:
# class-wise result
class_wise_gcv1 = metrics.classification_report(y_test, y_pred_best1)
print(class_wise_gcv1)
In [126]:
#When used GridSerach CV with PCA-9 componenets it gives compareable results when used GridSearch CV with svc algo only.
#We can consider this to be better as it uses less no of features thus making it less complex.
In [127]:
#The vehicles chosen are readily distinguishable bus, van and car.
#But there is no seperablity shown in data between 2 cars.
In [128]:
#GridSearch CV with SVC
#precision - a class labelled as car turns is correct 96% of the time, similarly for other classes as well.
#recall - car is actually recognized as car 95% of time by algo, similarly for other classes as well.
#So model does a good job with accuracy of 95.2%
#Accuracy: 0.9529411764705882
# precision recall f1-score support
#
# bus 0.96 0.98 0.97 48
# car 0.96 0.95 0.96 80
# van 0.93 0.93 0.93 42
# micro avg 0.95 0.95 0.95 170
# macro avg 0.95 0.95 0.95 170
#weighted avg 0.95 0.95 0.95 170
#GridSearch CV with SVC and PCA-9
#precision - a class labelled as car turns is correct 96% of the time, similarly for other classes as well.
#recall - car is actually recognized as car 91% of time by algo, similarly for other classes as well.
#So model does a good job with accuracy of 93.5%
#Accuracy: 0.9352941176470588
# precision recall f1-score support
#
# bus 0.94 0.98 0.96 48
# car 0.96 0.91 0.94 80
# van 0.89 0.93 0.91 42
# micro avg 0.94 0.94 0.94 170
# macro avg 0.93 0.94 0.93 170
#weighted avg 0.94 0.94 0.94 170